import random
from typing import List, Tuple
from enum import Enum
from dataclasses import dataclass
from datetime import datetime

class PriceProcessStrategy(Enum):
    """价格处理策略"""
    HIGH_LOW_RANDOM = 1  # 在最高价和最低价之间随机生成多个价格
    HIGH_LOW_ONLY = 2    # 只取最高价和最低价
    ALL_PRICES = 3       # 取所有价格（开盘、最高、最低、收盘）

@dataclass
class KlineData:
    """K线数据结构"""
    timestamp: int
    open_price: float
    high_price: float
    low_price: float
    close_price: float
    
    @classmethod
    def from_raw_data(cls, raw_data: List) -> 'KlineData':
        """从原始数据创建KlineData对象"""
        return cls(
            timestamp=int(raw_data[0]),
            open_price=float(raw_data[1]),
            high_price=float(raw_data[2]),
            low_price=float(raw_data[3]),
            close_price=float(raw_data[4])
        )

class PriceProcessor:
    """价格数据处理器"""
    
    @staticmethod
    def generate_random_prices(low: float, high: float, count: int) -> List[float]:
        """在最高价和最低价之间生成随机价格"""
        if count <= 0:
            return []
        return [round(random.uniform(low, high), 8) for _ in range(count)]

    @staticmethod
    def process_kline_data(
        raw_data: List[List],
        strategy: PriceProcessStrategy,
        random_count: int = 5
    ) -> List[float]:
        """处理单个时间段的K线数据
        
        Args:
            raw_data: 原始K线数据列表
            strategy: 处理策略
            random_count: 随机生成价格的数量（仅在HIGH_LOW_RANDOM策略中使用）
            
        Returns:
            处理后的价格列表
        """
        result = []
        
        for kline in raw_data:
            kdata = KlineData.from_raw_data(kline)
            
            if strategy == PriceProcessStrategy.HIGH_LOW_RANDOM:
                # 在最高价和最低价之间随机生成价格
                prices = PriceProcessor.generate_random_prices(
                    kdata.low_price,
                    kdata.high_price,
                    random_count
                )
                result.extend(prices)
                
            elif strategy == PriceProcessStrategy.HIGH_LOW_ONLY:
                # 只取最高价和最低价，并在内部随机打乱
                prices = [kdata.high_price, kdata.low_price]
                random.shuffle(prices)  # 只打乱当前K线的高低价
                result.extend(prices)
                
            elif strategy == PriceProcessStrategy.ALL_PRICES:
                # 取所有价格
                result.extend([
                    kdata.open_price,
                    kdata.high_price,
                    kdata.low_price,
                    kdata.close_price
                ])
        
        return result

    @staticmethod
    def merge_time_series_data(data_series: List[Tuple[datetime, List[float]]]) -> List[float]:
        """合并多个时间序列的数据
        
        Args:
            data_series: 包含时间戳和价格列表的元组列表，按时间顺序排列
            
        Returns:
            合并后的价格列表
        """
        # 按时间戳排序
        sorted_data = sorted(data_series, key=lambda x: x[0])
        
        # 合并所有价格列表
        merged_prices = []
        for _, prices in sorted_data:
            merged_prices.extend(prices)
            
        return merged_prices 